Rust异步编程async/.await原理解析（一）

您所在的位置：网站首页 › unless or区别 › Rust异步编程async/.await原理解析（一）

Rust异步编程async/.await原理解析（一）

2024-07-15 21:36| 来源: 网络整理| 查看: 265

在这个教程中我们将详细分析rust异步代码async/.await的内部运行机制。我们将使用async-std库而不是tokio，因为这是第一个支持async/.await语法的rust库。async/.await原理解析教程分为两部分，这是第一部分。

0、准备Rust练习环境

首先让我们先创建一个Cargo项目：

1~$ cargo new --bin sleepus-interruptus

如果你期望和教程使用的编译器保持一致，可以添加一个内容为 1.39.0的rust-toolchain文件。

在继续下面的内容之前，先运行cargo run确保环境没有问题。

1、一个交替显示的Rust程序

我们要写一个简单的程序，它可以显示10次Sleepus消息，每次间隔 0.5秒；同时显示5次Interruptus消息，每次间隔1秒。下面是相当简单的rust实现代码：

123456789101112131415161718192021use std::thread::{sleep};use std::time::Duration;fn sleepus() { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)); }}fn interruptus() { for i in 1..=5 { println!("Interruptus {}", i); sleep(Duration::from_millis(1000)); }}fn main() { sleepus(); interruptus();}

不过，上面的代码会同步执行两个操作，它会先显示完所有的Sleepus消息，然后再显示Interruptus消息。而我们期望的是这两种消息交织显示，也就是说 Interruptus消息可以打断Sleepus消息的显示。

有两个办法可以实现交织显示的目标。显而易见的一个是为每个函数创建一个单独的线程，然后等待线程执行完毕。

123456789use std::thread::{sleep, spawn};fn main() { let sleepus = spawn(sleepus); let interruptus = spawn(interruptus); sleepus.join().unwrap(); interruptus.join().unwrap();}

需要指出的是：

我们使用spawn(sleepus)而不是spawn(sleepus())来创建线程。后者将立即执行sleepus()然后将其执行结果传给spawn，这不是我们期望的我在主函数种使用join()来等待子线程结束，并使用unwrap()来处理可以发生的故障，因为我懒。

另一种实现方法是创建一个辅助线程，然后在主线程种调用其中一个函数：

123456fn main() { let sleepus = spawn(sleepus); interruptus(); sleepus.join().unwrap();}

这种方法效率更高，因为只需要额外创建一个线程，并且也没有什么副作用，因此我推荐使用这个方法。

不过这两种方法都不是异步解决方案！我们使用两个由操作系统管理的线程来并发执行两个同步任务！接下来让我们尝试如何在单一线程内让两个任务协作执行！

2、用Rust异步async/.await实现交替显示程序

我们将从较高层次的抽象开始，然后逐步深入rust异步编程的细节。现在让我们以async风格重写前面的应用。

首先在Cargo.toml中添加以下依赖：

1async-std = { version = "1.2.0", features = ["attributes"] }

现在我们可以将应用重写为：

123456789101112131415161718192021222324use async_std::task::{sleep, spawn};use std::time::Duration;async fn sleepus() { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)).await; }}async fn interruptus() { for i in 1..=5 { println!("Interruptus {}", i); sleep(Duration::from_millis(1000)).await; }}#[async_std::main]async fn main() { let sleepus = spawn(sleepus()); interruptus().await; sleepus.await;}

主要的修改说明如下：

我们不再使用std::thread中的sleep和spawn函数，而是采用async_std::task。在sleepus和interruptus函数前都加async 在调用sleep之后，我们补充了.await。注意不是.await()调用，而是一个新语法在主函数上使用#[async_std::main]属性主函数前也有async关键字我们现在使用spawn(sleepus())而不是spawn(sleepus)，这表示直接调用sleepus 并将结果传给spawn 对interruptus()的调用增加.await 对sleepus不再使用join()，而是改用.await语法

看起来有很多修改，不过实际上，我们的代码结构和之前的版本基本是一致的。现在程序运行和我们的期望一致：采用单一线程进行无阻塞调用。

接下来让我们分析上述修改到底意味着什么。

3、async关键字的作用

在函数定义前添加async主要做了以下3个事：

这将允许你在函数体内使用.await语法。我们接下来会深入探讨这一点它修改了函数的返回类型。async fn foo() -> Bar 实际上返回的是 impl std::future::Future 它自动将结果值封装进一个新的Future对象。我们下面会详细展示这一点

现在让我们展开说明第2点。在Rust的标准库中有一个名为Future的trait， Future有一个关联类型Output。这个trait的意思是：我承诺当我完成任务时，会给你一个类型为Output的值。例如你可以想象一个异步HTTP客户端可能会这样实现：

123impl HttpRequest { fn perform(self) -> impl Future { ... }}

在发送HTTP请求时需要一些无阻塞的I/O，我们并不希望阻塞调用线程，但是需要最终得到响应结果。

async fn sleepus()的结果类型隐含为()。因此我们的Future的Output 也应该为()。这意味着我们需要修改函数为：

1fn sleepus() -> impl std::future::Future

不过如果只修改这里，编译就会出现如下错误：

12345678910111213141516error[E0728]: `await` is only allowed inside `async` functions and blocks --> src/main.rs:7:9 |4 | fn sleepus() -> impl std::future::Future { | ------- this is not `async`...7 | sleep(Duration::from_millis(500)).await; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ only allowed inside `async` functions and blockserror[E0277]: the trait bound `(): std::future::Future` is not satisfied --> src/main.rs:4:17 |4 | fn sleepus() -> impl std::future::Future { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `()` | = note: the return type of a function must have a statically known size

第一个错误信息很直接：你只能在async函数或代码块中使用.await语法。我们还没有接触到异步代码块，不过看起来就是这样：

123async { // async noises intensify}

第二个错误消息就是第一个的结果：async关键字要求函数返回类型是impl Future。如果没有这个关键字，我们的loop结果类型是()，这显然不满足要求。

将整个函数体用一个异步代码块包裹起来就解决问题了：

12345678fn sleepus() -> impl std::future::Future { async { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)).await; } }} 4、.await语法的作用

可能我们并不需要所有这些async/.await。如果我们移除sleepus的.await 会怎么样？令人吃惊的是，居然编译通过了，虽然给出了一个警告：

12345678warning: unused implementer of `std::future::Future` that must be used --> src/main.rs:8:13 |8 | sleep(Duration::from_millis(500)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_must_use)]` on by default = note: futures do nothing unless you `.await` or poll them

我们在生成一个Future值但没有使用它。如果查看程序的输出，你可以理解编译器的警告是什么意思了：

123456789101112131415Interruptus 1Sleepus 1Sleepus 2Sleepus 3Sleepus 4Sleepus 5Sleepus 6Sleepus 7Sleepus 8Sleepus 9Sleepus 10Interruptus 2Interruptus 3Interruptus 4Interruptus 5

我们所有的Sleepus消息输出都没有延迟。问题在于对sleep的调用实际上没有让当前线程休息，它只是生成一个实现了Future的值，然后当承诺最终实现时，我们知道的确发生了延迟。但是由于我们简单地忽略了Future，因此实际上没有利用延迟。

为了理解.await语法到底做了什么，我们接下来直接使用Future值来实现我们的函数。首先从不用async块开始。

5、不使用async关键字的Rust异步代码

如果我们丢掉async代码块，看起来就是这样：

123456fn sleepus() -> impl std::future::Future { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)); }}

这样编译会出现以下错误：

123456error[E0277]: the trait bound `(): std::future::Future` is not satisfied --> src/main.rs:4:17 |4 | fn sleepus() -> impl std::future::Future { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `()` |

上面错误是由于for循环的结果类型为()，它没有实现Future这个trait。修复这个问题的一种办法是在for循环后面加一句话使其返回Future的实现类型。我们已经知道可以用这个：sleep：

1234567fn sleepus() -> impl std::future::Future { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)); } sleep(Duration::from_millis(0))}

现在我们依然会看到在for循环内存在未使用的Future值的警告信息，不过返回值那个错误已经解决掉了。这个sleep调用实际上什么也没做，我们可以将其替换为一个真正的占位Future：

1234567fn sleepus() -> impl std::future::Future { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)); } async_std::future::ready(())} 6、实现自己的Future

为了打破沙锅问到底，让我们再深入一步，不适用async_std库中的ready函数，而是定义自己的实现Future的结构。让我们称之为DoNothing。

1234567891011use std::future::Future;struct DoNothing;fn sleepus() -> impl Future { for i in 1..=10 { println!("Sleepus {}", i); sleep(Duration::from_millis(500)); } DoNothing}

问题在于DoNothing还没有提供Future实现。我们接下来将进行一些编译器驱动的开发，让rustc告诉我们如何修复这个程序。第一个错误信息是：

1the trait bound `DoNothing: std::future::Future` is not satisfied

因此让我们补上这个trait的实现：

12impl Future for DoNothing {}

继续报错：

12345678error[E0046]: not all trait items implemented, missing: `Output`, `poll` --> src/main.rs:7:1 |7 | impl Future for DoNothing { | ^^^^^^^^^^^^^^^^^^^^^^^^^ missing `Output`, `poll` in implementation | = note: `Output` from trait: `type Output;` = note: `poll` from trait: `fn(std::pin::Pin, &mut std::task::Context

【本文地址】

公司简介

联系我们